home *** CD-ROM | disk | FTP | other *** search
/ Revolution - Das Atari CD Magazin 1997 / Revolution - Das Atari CD Magazin 1.iso / software / anwendng / qed_397 / sourcen / edit.c < prev    next >
C/C++ Source or Header  |  1997-01-15  |  50KB  |  2,205 lines
  1. #include "global.h"
  2. #include "ausgabe.h"
  3. #include "av.h"
  4. #include "block.h"
  5. #include "clipbrd.h"
  6. #include "comm.h"
  7. #include "dd.h"
  8. #include "desktop.h"
  9. #include "error.h"
  10. #include "file.h"
  11. #include "find.h"
  12. #include "fontsel.h"
  13. #include "icon.h"
  14. #include "kurzel.h"
  15. #include "makro.h"
  16. #include "menu.h"
  17. #include "obj.h"
  18. #include "olga.h"
  19. #include "printer.h"
  20. #include "projekt.h"
  21. #include "rsc.h"
  22. #include "scroll.h"
  23. #include "set.h"
  24. #include "tasten.h"
  25. #include "text.h"
  26. #include "umbruch.h"
  27. #include "windows.h"
  28. #include "edit.h"
  29.  
  30. /* Exportierte Variablen ***************************************************/
  31.  
  32. WORD    edit_type;
  33.  
  34. /****** DEFINES ************************************************************/
  35.  
  36. #define KIND    (NAME|INFO|CLOSER|FULLER|MOVER|SIZER|UPARROW|DNARROW|VSLIDE|LFARROW|RTARROW|HSLIDE|SMALLER)
  37. #define FLAGS    (WI_MOUSE|WI_TEXT|WI_FONTSIZE|WI_REDRAW)
  38.  
  39. /* Anzahl der Änderungen in allen Texten bis zum restore_edit */
  40. #define MAX_CHG 30
  41.  
  42. #define TEMP_LINK 10001
  43.  
  44. /****** TYPES **************************************************************/
  45.  
  46. typedef struct
  47. {
  48.     WORD    link;         /* Nummer von Text und Window */
  49.     WORD    c;         /* Art der Änderung */
  50.     LONG    y;         /* y-Position */
  51. } TCHANGE;
  52.  
  53. /* lokale Variablen ********************************************************/
  54. LOCAL SET        used_info;    /* Icon-Nr für Text und Fenster */
  55. LOCAL WORD        chg_anz, find_erg, namenlos_anz, ascii_wert;
  56. LOCAL TCHANGE     chg[MAX_CHG];
  57. LOCAL SET        chg_links;
  58.  
  59. /* lokale Prototypen *******************************************************/
  60.  
  61. LOCAL VOID         icon_exist        (WORD icon, SET actions);
  62. LOCAL BOOLEAN     icon_test        (WORD icon, WORD action);
  63. LOCAL WORD        icon_edit        (WORD icon, WORD action);
  64. LOCAL BOOLEAN     icon_drag        (WORD icon, WORD source);
  65. LOCAL VOID         wi_click         (WINDOWP window, MKINFO *mk);
  66. LOCAL BOOLEAN     wi_key            (WINDOWP window, MKINFO *mk);
  67. LOCAL VOID         wi_top            (WINDOWP window);
  68. LOCAL    VOID        wi_iconify        (WINDOWP window);
  69. LOCAL    VOID        wi_uniconify    (WINDOWP window);
  70. LOCAL VOID         destruct         (WORD icon);
  71.  
  72. LOCAL VOID         lz2tab            (TEXTP t_ptr);
  73. LOCAL VOID         tab2lz            (TEXTP t_ptr);
  74. LOCAL VOID         cut_lines        (TEXTP t_ptr);
  75. LOCAL VOID         goto_line        (TEXTP t_ptr, WORD x, LONG y);
  76. LOCAL VOID         make_undo        (TEXTP t_ptr);
  77. LOCAL VOID         print_edit        (TEXTP t_ptr);
  78. LOCAL BOOLEAN     open_edit        (WORD icon);
  79. LOCAL VOID         crt_edit         (WORD icon, WINDOWP window);
  80. LOCAL WORD      crt_new_text    (CONST UBYTE *filename, WORD icon_x, WORD icon_y, RECT *win);
  81.  
  82. /* Zeichentabelle */
  83. LOCAL WORD        get_ascii        (VOID);
  84.  
  85. /***************************************************************************/
  86.  
  87. WORD anz_loaded(VOID)
  88. {
  89.     return (setcard(used_info));
  90. }
  91.  
  92. WORD still_loaded(CONST UBYTE *name)
  93. {
  94.     WORD i, min;
  95.  
  96.     min = setmin(used_info);
  97.     for (i=setmax(used_info); i>=min; i--)
  98.         if (setin(used_info,i))
  99.         {
  100.             TEXTP t_ptr = get_text(i);
  101.  
  102. /*            if (!t_ptr->namenlos && filematch(t_ptr->filename, name))*/
  103.             if (!t_ptr->namenlos && strcmp(t_ptr->filename, name)==0)
  104.                 return i;
  105.         }
  106.     return -1;
  107. }
  108.  
  109. LOCAL WORD col_lz2tab(LINEP col, UBYTE *t, WORD tab_size)
  110. {
  111.     UBYTE        *str, c;
  112.     WORD        i, tabH, lz, len;
  113.     BOOLEAN    changes;
  114.  
  115.     str = TEXT(col);
  116.     changes = FALSE;
  117.     tabH = tab_size;
  118.     lz = 0;
  119.     len = 0;
  120.     for (i=col->len; (--i)>=0; )
  121.     {
  122.         c = *str++;
  123.         if (c==' ')
  124.         {
  125.             if ((--tabH)==0)
  126.             {
  127.                 if (lz>0)            /* Leerzeichen ersetzen */
  128.                 {
  129.                     c = '\t';
  130.                     t -= lz;
  131.                     len -= lz;
  132.                     changes = TRUE;
  133.                 }
  134.                 tabH = tab_size;
  135.                 lz = 0;
  136.             }
  137.             else
  138.                 lz++;
  139.         }
  140.         else
  141.         {
  142.             lz = 0;
  143.             if ((--tabH)==0) tabH = tab_size;
  144.         }
  145.         *t++ = c;
  146.         len++;
  147.     }
  148.     *t = EOS;
  149.     if (changes)
  150.         return (len);
  151.     return (-1);
  152. }
  153.  
  154. LOCAL VOID lz2tab(TEXTP t_ptr)
  155. {
  156.     LINEP lauf;
  157.     WORD    x, i, tabsize;
  158.     UBYTE    str[260];
  159.  
  160.     Busy_mouse();
  161.     tabsize = t_ptr->loc_opt->tabsize;
  162.     x = BildPos(t_ptr->xpos,t_ptr->cursor_line,TRUE,tabsize);
  163.     lauf = FIRST(&t_ptr->text);
  164.     while (!IS_TAIL(lauf))
  165.     {
  166.         i = col_lz2tab(lauf, str, tabsize);
  167.         if (i != -1)                                    /* Zeile verändert */
  168.         {
  169.             REALLOC (&lauf, 0, i-lauf->len);
  170.             COPYW (TEXT(lauf), str, (short) strlen(str));
  171.             t_ptr->moved++;
  172.         }
  173.         NEXT(lauf);
  174.     }
  175.     t_ptr->cursor_line = get_line(&t_ptr->text,t_ptr->ypos);
  176.     t_ptr->xpos = InterPos(x,t_ptr->cursor_line,TRUE,tabsize);
  177.     make_chg(t_ptr->link,POS_CHANGE,0);     /* immer: Damit Infozeile einen '*' bekommt */
  178.     restore_edit();
  179.     Last_mouse();
  180. }
  181.  
  182. LOCAL WORD col_tab2lz(LINEP col, UBYTE *t, WORD tab_size)
  183. {
  184.     BOOLEAN    with_tab = FALSE;
  185.     WORD        tabH, len, i;
  186.     UBYTE        *str, c;
  187.  
  188.     str = TEXT(col);
  189.     tabH = tab_size;
  190.     for (i = col->len,len = 0; (--i) >= 0 && (len < (MAX_LINE_LEN+1)); )
  191.     {
  192.         c = *str++;
  193.         if (c == '\t')
  194.         {
  195.             with_tab = TRUE;
  196.             len += tabH;
  197.             if (len > (MAX_LINE_LEN+1))
  198.                 tabH -= (len - (MAX_LINE_LEN+1));
  199.             do
  200.             {
  201.                 *t++ = ' ';
  202.             }
  203.             while (--tabH);
  204.             tabH = tab_size;
  205.         }
  206.         else
  207.         {
  208.             *t++ = c;
  209.             if ((--tabH)==0)
  210.                 tabH = tab_size;
  211.             len++;
  212.         }
  213.     }
  214.     *t = EOS;
  215.     if (with_tab)
  216.         return(len);
  217.     else
  218.         return(-1);
  219. }
  220.  
  221. LOCAL VOID tab2lz(TEXTP t_ptr)
  222. {
  223.     LINEP lauf;
  224.     WORD    i, x, tabsize;
  225.     UBYTE    str[MAX_LINE_LEN + 1];
  226.  
  227.     Busy_mouse();
  228.     tabsize = t_ptr->loc_opt->tabsize;
  229.     x = BildPos(t_ptr->xpos,t_ptr->cursor_line,TRUE,tabsize);
  230.     lauf = FIRST(&t_ptr->text);
  231.     while (!IS_TAIL(lauf))
  232.     {
  233.         i = col_tab2lz (lauf,str,tabsize);
  234.         if (i != -1)                                    /* Zeile verändert */
  235.         {
  236.             REALLOC (&lauf, 0, i-lauf->len);
  237.             COPYW (TEXT(lauf), str, (short)strlen(str));
  238.             t_ptr->moved++;
  239.         }
  240.         NEXT(lauf);
  241.     }
  242.     t_ptr->cursor_line = get_line(&t_ptr->text,t_ptr->ypos);
  243.     t_ptr->xpos = InterPos(x,t_ptr->cursor_line,TRUE,tabsize);
  244.     make_chg(t_ptr->link,POS_CHANGE,0);     /* immer: Damit Infozeile einen '*' bekommt */
  245.     restore_edit();
  246.     Last_mouse();
  247. }
  248.  
  249. LOCAL VOID cut_lines(TEXTP t_ptr)
  250. {
  251.     LINEP lauf;
  252.     WORD    i;
  253.     UBYTE    c;
  254.  
  255.     lauf = FIRST(&t_ptr->text);
  256.     while (!IS_TAIL(lauf))
  257.     {
  258.         for (i=lauf->len; (--i)>=0 ; )
  259.         {
  260.             c = TEXT(lauf)[i];
  261.             if (c!=' ' && c!='\t') break;
  262.         }
  263.         i++;
  264.         if (i<lauf->len)        /* Zeile verkürzen */
  265.         {
  266.             REALLOC(&lauf,i,i-lauf->len);
  267.             t_ptr->moved++;
  268.         }
  269.         NEXT(lauf);
  270.     }
  271.     lauf = t_ptr->cursor_line = get_line(&t_ptr->text,t_ptr->ypos);
  272.     if (t_ptr->xpos>lauf->len)
  273.         t_ptr->xpos = lauf->len;
  274.     make_chg(t_ptr->link,POS_CHANGE,0);     /* immer: Damit Infozeile einen '*' bekommt */
  275. }
  276.  
  277. LOCAL VOID goto_line(TEXTP t_ptr, WORD x, LONG y)
  278. {
  279.     if (x < 0)
  280.         x = 0;
  281.     if (y < 0)
  282.         y = 0;
  283.     if (y >= t_ptr->text.lines)
  284.         y = t_ptr->text.lines - 1L;
  285.     t_ptr->cursor_line = get_line(&t_ptr->text, y);
  286.     t_ptr->ypos = y;
  287.     t_ptr->xpos = InterPos(x,t_ptr->cursor_line,t_ptr->loc_opt->tab,t_ptr->loc_opt->tabsize);
  288.     make_chg(t_ptr->link,POS_CHANGE, 0);
  289. }
  290.  
  291. LOCAL VOID make_undo(TEXTP t_ptr)
  292. {
  293.     WORD undo;
  294.  
  295.     undo = get_undo();
  296.     if (undo==NO_UNDO) return;
  297.     /* Vorher an undo_pos springen                    */
  298.     /* Weil sonst u.U. restore zu schwierig        */
  299.     /* Wird auch von do_undo_col vorausgesetzt    */
  300.     t_ptr->cursor_line = get_line(&t_ptr->text,undo_y);
  301.     t_ptr->ypos = undo_y;
  302.     t_ptr->xpos = 0;
  303.     make_chg(t_ptr->link,POS_CHANGE,0);
  304.     restore_edit();
  305.  
  306.     do{
  307.         if (undo==COL_ANDERS)
  308.         {
  309.             do_undo_col(t_ptr,undo);
  310.             restore_edit();
  311.         }
  312.         else
  313.         {
  314.             blk_undo(t_ptr,undo);
  315.             restore_edit();
  316.         }
  317.         undo = get_undo();
  318.     }while (undo!=NO_UNDO);
  319. }
  320.  
  321. /***************************************************************************/
  322.  
  323. LOCAL VOID do_absatz(WINDP window)
  324. {
  325.     if (window->flags&WI_TEXT)                     /* Text-Fenster */
  326.     {
  327.         make_absatz(get_text(window->link));
  328.         redraw_window(window, &window->work);
  329.     }
  330. }
  331.  
  332.  
  333. VOID absatz_edit(VOID)
  334. /* Es wurde Zeilenumbruch ein oder ausgeschaltet und/oder Tab geändert */
  335. {
  336.     get_all_windows(CLASS_EDIT, SRCH_ANY, do_absatz);
  337. }
  338.  
  339.  
  340. /***************************************************************************/
  341.  
  342. LOCAL VOID chg_edit_name(WORD icon)
  343. {
  344.     WINDP window;
  345.     PATH    name;
  346.     TEXTP t_ptr = get_text(icon);
  347.  
  348.     file_name(t_ptr->filename, name, FALSE);
  349.     window = get_window (icon);
  350.     set_icon_name(icon,name);
  351.     make_shortpath(t_ptr->filename, name, 70);
  352.     set_wname(window,name);
  353. }
  354.  
  355. /***************************************************************************/
  356. /* Anlegen einer neuen Textdatei                                                         */
  357. /***************************************************************************/
  358.  
  359. WORD new_edit(VOID)
  360. {
  361.     WORD    icon;
  362.     TEXTP t_ptr;
  363.  
  364.     icon = crt_new_text("",-1,-1,NULL);
  365.     if (icon < 0)
  366.     {
  367.         note(1,NOTEXT);
  368.         return -1;
  369.     }
  370.     t_ptr = get_text(icon);
  371.     if (t_ptr->loc_opt->umbrechen)
  372.         make_absatz(t_ptr);
  373.     if (!(nkc_kstate() & 3L) || no_desktop)
  374.     {
  375.         if (do_icon(icon,DO_OPEN) < 0)
  376.         {
  377.             note(1, NOWINDOW);
  378.             if (no_desktop)
  379.             {
  380.                 Icon_edit(icon, DO_DESTRUCT);
  381.                 icon = -3;
  382.             }
  383.         }
  384.     }
  385.     return icon;
  386. } /* new_edit */
  387.  
  388. /***************************************************************************/
  389.  
  390. WORD load_edit(CONST UBYTE *name, BOOLEAN open, WORD icon_x, WORD icon_y, RECT *win)
  391. /* return: <=0 wurde nicht geladen */
  392. /*           =0    weitere Texte versuchen sinnvoll */
  393. /*           <0    weiter Texte versuchen nicht sinnvoll */
  394. {
  395.     WINDP     window;
  396.     TEXTP     t_ptr;
  397.     FILENAME    datei;
  398.     PATH        path;
  399.     WORD        err, icon;
  400.  
  401.     set_fsel_path(name);
  402.     file_splitt(name, path, datei);
  403.     if ((icon=still_loaded(name))>0)                     /* schon geladen */
  404.     {
  405.         if (do_icon(icon,DO_OPEN)<0)                        /* nur Fenster auf */
  406.             note(1, NOWINDOW);
  407.         return icon;
  408.     }
  409.     icon = crt_new_text(name, icon_x, icon_y, win); /* neuen Text anlegen */
  410.     if (icon<0)
  411.     {
  412.         note(1,NOTEXT);
  413.         return -1;                                                /* hat keinen Zweck mehr */
  414.     }
  415.     t_ptr = get_text(icon);
  416.     if ((err=load(t_ptr, TRUE))==-33)                    /* File not Found */
  417.     {
  418.         if (path_exist(path))
  419.         {
  420.             if (snote(1,NEWTEXT,datei)==2)                /* neue Datei anlegen */
  421.             {
  422.                 Icon_edit(icon,DO_DESTRUCT);
  423.                 return 0;                                        /* naechsten versuche */
  424.             }
  425.         }
  426.         else
  427.         {
  428.             snote(1, READERR, datei);
  429.             Icon_edit(icon,DO_DESTRUCT);
  430.             return 0;                                            /* naechsten versuchen */
  431.         }
  432.     }
  433.     else if (err)                                                /* anderer Fehler */
  434.     {
  435.         snote(1, READERR, datei);
  436.         Icon_edit(icon,DO_DESTRUCT);
  437.         return 0;
  438.     }
  439.     if (t_ptr->loc_opt->umbrechen)
  440.     {
  441.         make_absatz(t_ptr);
  442.         if (t_ptr->loc_opt->format_by_load)
  443.             total_format(t_ptr);
  444.     }
  445.     window = get_window(icon);
  446.     window->doc.x = 0;
  447.     window->doc.y = 0;
  448.     window->doc.h = t_ptr->text.lines;
  449.     if (t_ptr->moved)                                            /* wurde umgebrochen? */
  450.     {
  451.         set_info(t_ptr, STRING(UMBRUCHSTR));
  452.         change_window(window, TRUE);
  453.     }
  454.     if ((open && !(nkc_kstate() & 3L)) || no_desktop)
  455.     {
  456.         if (do_icon(icon,DO_OPEN)<0 && no_desktop)
  457.         {
  458.             note(1, NOWINDOW);
  459.             Icon_edit(icon,DO_DESTRUCT);
  460.             icon = -2;
  461.         }
  462.     }
  463.     return icon;
  464. }
  465.  
  466. /***************************************************************************/
  467.  
  468. LOCAL VOID print_edit (TEXTP t_ptr)
  469. {
  470.     FILENAME name;
  471.  
  472.     if (t_ptr->namenlos)
  473.         strcpy(name, t_ptr->filename);
  474.     else
  475.         file_name(t_ptr->filename, name, FALSE);
  476.     if (prn_options(name, t_ptr->block))
  477.     {
  478.         if (print_block)
  479.             blk_drucken(name, t_ptr);
  480.         else
  481.             txt_drucken(name, t_ptr);
  482.     }
  483. } /* print_edit */
  484.  
  485. /***************************************************************************/
  486.  
  487. LOCAL BOOLEAN delete_edit(WORD icon, TEXTP t_ptr)
  488. {
  489.     WORD    antw;
  490.     FILENAME    name;
  491.  
  492.     if (t_ptr->moved != 0)
  493.     {
  494.         if (quick_close)
  495.             antw = 1;
  496.         else
  497.         {
  498.             if (t_ptr->namenlos)
  499.                 strcpy(name, t_ptr->filename);
  500.             else
  501.                 file_name(t_ptr->filename, name, FALSE);
  502.             antw = snote(1, MOVED, name);
  503.         }
  504.         if (antw == 1)
  505.         {
  506.             if (do_icon(icon,DO_SAVE) < 0)
  507.                 return (FALSE);
  508.         }
  509.         if (antw == 3)
  510.             return(FALSE);
  511.     }
  512.     return (TRUE);
  513. }
  514.  
  515. /***************************************************************************/
  516. /* Fenster angeclickt                                                                        */
  517. /***************************************************************************/
  518.  
  519. LOCAL VOID set_cursor(WINDOWP window, MKINFO *mk)
  520. {
  521.     TEXTP t_ptr = get_text(window->link);
  522.     WORD    x;
  523.     LONG    y;
  524.     LINEP col;
  525.  
  526.     y = (mk->moy - window->work.y);
  527.     if (y < 0)
  528.         y -= gl_hchar;     /* wg. Rundung */
  529.     y /= gl_hchar;
  530.     y += window->doc.y;
  531.     if (y >= t_ptr->text.lines)
  532.         y = t_ptr->text.lines-1;
  533.     else if (y < 0)
  534.         y = 0;
  535.     col = get_line(&t_ptr->text, y);
  536.  
  537.     t_ptr->ypos = y;
  538.     t_ptr->cursor_line = col;
  539.     if (winFont.prop)
  540.     {
  541.         WORD i, x_soll;
  542.  
  543.         x_soll = (mk->mox - window->work.x) + ((short) window->doc.x * gl_wchar);
  544.         for (x=col->len; x>0; x--)
  545.         {
  546.             t_ptr->xpos = x;
  547.             i = cursor_xpos(t_ptr, t_ptr->xpos);
  548.             if (i<=x_soll) break;
  549.         }
  550.     }
  551.     else
  552.     {
  553.         x = mk->mox - window->work.x;
  554.         if (x > 0)
  555.         {
  556.             x /= gl_wchar;
  557.             x += (short) window->doc.x;
  558.         }
  559.         else if (window->doc.x>0)
  560.             x = (short) window->doc.x-1;
  561.         else
  562.             x = 0;
  563.         x = InterPos(x,col,t_ptr->loc_opt->tab,t_ptr->loc_opt->tabsize);
  564.     }
  565.     t_ptr->xpos = x;
  566.  
  567.     y -= window->doc.y;
  568.     if (y > 0)
  569.     {
  570.         if (y > window->w_hight)
  571.             make_chg(t_ptr->link,MOVE_UP, y-window->w_hight);
  572.     }
  573.     else
  574.         make_chg(t_ptr->link,MOVE_DOWN, -y);
  575.     make_chg(t_ptr->link,POS_CHANGE, 0);
  576. }
  577.  
  578. #define LINE_MODE    1
  579. #define WORD_MODE    2
  580. #define KEY_MODE    3
  581.  
  582. LOCAL VOID wi_click (WINDOWP window, MKINFO *mk)
  583. {
  584.     WORD    event, kreturn, mode;
  585.     TEXTP t_ptr = get_text(window->link);
  586.     RECT    *s = &window->work;
  587.  
  588.     /* Infomeldung löschen */
  589.     unset_info(t_ptr);
  590.  
  591.     if (mk->mobutton & 2)                 /* Rechtsclick */
  592.     {
  593.         if (strlen(error[0]) > 0)
  594.         {
  595.             blk_demark(t_ptr);
  596.             set_cursor(window,mk);
  597.             restore_edit();
  598.             handle_error(t_ptr);
  599.         }
  600.         return;                                /* und wech... */
  601.     }
  602.  
  603.     if (!inside(mk->mox,mk->moy,s))
  604.         return;
  605.     t_ptr->blk_mark_mode = FALSE;
  606.     unclick_window();
  607.     if (mk->breturn == 2)                /* Doppelklick */
  608.     {
  609.         blk_demark(t_ptr);
  610.         set_cursor(window,mk);
  611.         restore_edit();
  612.         if (mk->kstate & (K_RSHIFT|K_LSHIFT)||                    /* Ganze Zeile markieren */
  613.              t_ptr->xpos==t_ptr->cursor_line->len)
  614.         {
  615.             t_ptr->xpos = 0;
  616.             blk_mark(t_ptr, 0);
  617.             if (IS_LAST(t_ptr->cursor_line))
  618.                 t_ptr->xpos = t_ptr->cursor_line->len;
  619.             else
  620.             {
  621.                 NEXT(t_ptr->cursor_line);
  622.                 t_ptr->ypos++;
  623.             }
  624.             blk_mark(t_ptr, 1);
  625.             restore_edit();
  626.             mode = LINE_MODE;
  627.         }
  628.         else                                                                /* wortweise */
  629.         {
  630.             blk_mark_word(t_ptr);
  631.             mode = WORD_MODE;
  632.         }
  633.     }
  634.     else                                                                    /* Einfachklick */
  635.     {
  636.         if (mk->kstate&(K_RSHIFT|K_LSHIFT))
  637.         {
  638.             if (!t_ptr->block)
  639.                 blk_mark(t_ptr,0);    /* Anfang = alte Cursorpos */
  640.             set_cursor(window, mk);
  641.             blk_mark(t_ptr, 1);
  642.             restore_edit();
  643.         }
  644.         else
  645.         {
  646.             blk_demark(t_ptr);
  647.             set_cursor(window, mk);
  648.             blk_mark(t_ptr, 0);
  649.             restore_edit();
  650.         }
  651.         mode = KEY_MODE;
  652.     }
  653.     graf_mkstate (&mk->mox, &mk->moy, &mk->mobutton, &mk->kstate);
  654.     if (mk->mobutton&1)                                /* immernoch gedrückt */
  655.     {
  656.         Set_mouse(POINT_HAND);
  657.         wind_update (BEG_MCTRL);                    /* Mauskontrolle übernehmen */
  658.         while(TRUE)
  659.         {
  660.             event = evnt_multi ( MU_BUTTON | MU_M1 | MU_M2,
  661.                                         1, 0x01, 0x00,
  662.                                         TRUE, mk->mox, mk->moy, 1, 1,
  663.                                         TRUE, s->x, s->y, s->w, s->h,
  664.                                         NULL,
  665.                                         0, 0,
  666.                                         &mk->mox, &mk->moy,
  667.                                         &mk->mobutton, &mk->kstate,
  668.                                         &kreturn, &mk->breturn);
  669.             if (event&MU_BUTTON) break;
  670.             if (event & (MU_M1 | MU_M2))
  671.             {
  672.                 set_cursor(window, mk);
  673.                 if (mode==WORD_MODE)
  674.                 {
  675.                     LONG    y;
  676.                     WORD    x, pos,len;
  677.                     UBYTE    *str;
  678.  
  679.                     pos = t_ptr->xpos;
  680.                     str = TEXT(t_ptr->cursor_line)+pos;
  681.                     len = t_ptr->cursor_line->len;
  682.                     get_blk_mark(t_ptr,&y,&x);
  683.                     if (t_ptr->ypos > y || t_ptr->xpos > x)         /* nach rechts */
  684.                     {
  685.                         while(pos<=len && setin(t_ptr->loc_opt->wort_set,*str))
  686.                         {
  687.                             pos++;
  688.                             str++;
  689.                         }
  690.                     }
  691.                     else                                                    /* nach links */
  692.                     {
  693.                         while(pos>=0 && setin(t_ptr->loc_opt->wort_set,*str))
  694.                         {
  695.                             pos--;
  696.                             str--;
  697.                         }
  698.                         str++; pos++;
  699.                     }
  700.                     t_ptr->xpos = pos;
  701.                 }
  702.                 else if (mode==LINE_MODE)
  703.                 {
  704.                     LONG    y;
  705.                     WORD    x;
  706.  
  707.                     get_blk_mark(t_ptr,&y,&x);
  708.                     t_ptr->xpos = 0;
  709.                     if (y==t_ptr->ypos && !IS_LAST(t_ptr->cursor_line))
  710.                     {
  711.                         NEXT(t_ptr->cursor_line);
  712.                         t_ptr->ypos++;
  713.                     }
  714.                 }
  715.                 blk_mark(t_ptr, 1);
  716.                 restore_edit();
  717.             }
  718.         }
  719.         wind_update (END_MCTRL);                    /* Mauskontrolle wieder abgeben */
  720.         Last_mouse();
  721.     }
  722. }
  723.  
  724.  
  725. LOCAL BOOLEAN wi_key (WINDOWP window, MKINFO *mk)
  726. {
  727.     TEXTP t_ptr = get_text(window->link);
  728.  
  729.     /* Infomeldung löschen */
  730.     unset_info(t_ptr);
  731.  
  732.     if (key(t_ptr, window, mk))
  733.     {
  734.         restore_edit();
  735.         return TRUE;
  736.     }
  737.     return FALSE;
  738. }
  739.  
  740. /***************************************************************************/
  741. /* Zeichne Fensterinhalt                                                                    */
  742. /* Wird auch in CLIP-Fenster eingetragen                                                */
  743. /***************************************************************************/
  744.  
  745. VOID wi_draw_edit (WINDOWP window, const RECT *d)
  746. {
  747.     TEXTP t_ptr = get_text(window->link);
  748.  
  749.     if (d->x == window->work.x && d->w == window->work.w)
  750.     {
  751.         if (d->y == window->work.y + window->work.h - window->yfac &&
  752.              d->h == window->yfac)
  753.         {
  754.             /* Letzte Zeile */
  755.             set_clip(FALSE, NULL);    /* Clipping aus wg. Geschwindigkeit */
  756.             line_out(window, t_ptr, window->w_hight - 1);
  757.         }
  758.         else if (d->y == window->work.y && d->h == window->yfac)
  759.         {
  760.             /* Erste Zeile */
  761.             set_clip(FALSE, NULL);    /* Clipping aus wg. Geschwindigkeit */
  762.             line_out(window, t_ptr, 0);
  763.         }
  764.         else
  765.         {
  766.             if (d->y == window->work.y && d->h == window->work.h)
  767.                 set_clip(FALSE, NULL);    /* Clipping aus wg. Geschwindigkeit */
  768.             else
  769.                 set_clip(TRUE, d);
  770.             bild_out(window, t_ptr);
  771.         }
  772.     }
  773.     else
  774.     {
  775.         set_clip(TRUE, d);
  776.         bild_out(window,t_ptr);
  777.     }
  778. } /* wi_draw_edit */
  779.  
  780.  
  781. LOCAL VOID wi_top(WINDOWP window)
  782. {
  783.     TEXTP t_ptr = get_text(window->link);
  784.  
  785.     ch_kurzel(t_ptr->loc_opt->kurzel, FALSE);
  786. }
  787.  
  788. LOCAL    VOID        wi_iconify        (WINDOWP window)
  789. {
  790.     TEXTP     t_ptr = get_text(window->link);
  791.     FILENAME    short_name;
  792.  
  793.     make_shortpath(t_ptr->filename, short_name, 8);
  794.     set_wname(window, short_name);
  795. }
  796.  
  797. LOCAL    VOID        wi_uniconify    (WINDOWP window)
  798. {
  799.     TEXTP t_ptr = get_text(window->link);
  800.  
  801.     set_wname(window, t_ptr->filename);
  802. }
  803.  
  804. /***************************************************************************/
  805. /* Operation vorhanden ?                                                                    */
  806. /***************************************************************************/
  807.  
  808. LOCAL VOID icon_exist(WORD icon, SET actions)
  809. {
  810.     TEXTP t_ptr = get_text(icon),
  811.             clip_tptr = get_text(iclipbrd);
  812.     WINDP window = get_window(icon);
  813.  
  814.     setclr(actions);
  815.  
  816.     if (window->flags & WI_ICONIFIED)
  817.     {
  818.         /* Nötig, wenn Text geändert und qed Beendet wird! */
  819.         setincl(actions, DO_DESTRUCT);
  820.         return;
  821.     }
  822.  
  823.     if (any_undo())
  824.         setincl(actions,DO_UNDO);
  825.     if (t_ptr->block)
  826.     {
  827.         setincl(actions,DO_CUT);
  828.         setincl(actions,DO_COPY);
  829.         setincl(actions,DO_LEFT);
  830.         setincl(actions,DO_RIGHT);
  831.         setincl(actions,DO_ONE_LEFT);
  832.         setincl(actions,DO_ONE_RIGHT);
  833.         setincl(actions,DO_BIG2SMALL);
  834.         setincl(actions,DO_SMALL2BIG);
  835.         setincl(actions,DO_CHNG_SMBG);
  836.         setincl(actions,DO_CAPS);
  837.         setincl(actions,DO_GO_BLK_A);
  838.         setincl(actions,DO_GO_BLK_E);
  839.     }
  840.     else
  841.     {
  842.         setincl(actions, DO_LINECOPY);
  843.         setincl(actions, DO_SWAPCHAR);
  844.     }
  845.     if (t_ptr->loc_opt->tab)
  846.     {
  847.         setincl(actions,DO_TAB2LZ);
  848.         setincl(actions,DO_LZ2TAB);
  849.     }
  850.     if (t_ptr->loc_opt->umbrechen)
  851.         setincl(actions,DO_FORMAT);
  852.     else
  853.         setincl(actions,DO_CUTLINES);
  854.     if (window->opened)
  855.         setincl(actions,DO_CLOSE);
  856.     if (!ist_leer(&clip_tptr->text))
  857.         setincl(actions,DO_PASTE);
  858.     setincl(actions,DO_CLEAR);
  859.     setincl(actions,DO_SELALL);
  860.     setincl(actions,DO_DESTRUCT);
  861.     setincl(actions,DO_OPEN);
  862.     setincl(actions,DO_INFO);
  863.     setincl(actions,DO_HELP);
  864.     setincl(actions,DO_PRINT);
  865.     if (!t_ptr->namenlos)
  866.         setincl(actions,DO_ABAND);
  867.     setincl(actions,DO_SAVE);
  868.     setincl(actions,DO_SAVENEW);
  869.     setincl(actions,DO_FIND);
  870.     setincl(actions,DO_FINDNEXT);
  871.     setincl(actions,DO_GOTO);
  872.     setincl(actions,DO_ADD);
  873.     setincl(actions,DO_UPDATE);
  874.     setincl(actions, DO_ZEICHTAB);
  875.     setincl(actions, DO_UMLAUT);
  876.     setincl(actions, DO_AUTOSAVE);
  877.     setincl(actions, DO_FEHLER);
  878. }
  879.  
  880. /***************************************************************************/
  881. /* Operation testen                                                                            */
  882. /***************************************************************************/
  883.  
  884. LOCAL BOOLEAN icon_test(WORD icon, WORD action)
  885. {
  886.     BOOLEAN    erg;
  887.     TEXTP t_ptr = get_text(icon);
  888.     WINDP window = get_window(icon);
  889.     FILENAME    name;
  890.  
  891.     switch(action)
  892.     {
  893.         case DO_UNDO    :
  894.             erg = any_undo();
  895.             break;
  896.         case DO_CUT     :
  897.             erg = t_ptr->block;
  898.              break;
  899.         case DO_COPY    :
  900.             erg = t_ptr->block;
  901.             break;
  902.         case DO_LINECOPY:
  903.             erg = !(t_ptr->block);
  904.             break;
  905.         case DO_PASTE    :
  906.             erg = TRUE;
  907.             break;
  908.         case DO_CLEAR    :
  909.             erg = delete_edit(icon,t_ptr);
  910.             break;
  911.         case DO_SELALL :
  912.             erg = TRUE;
  913.             break;
  914.         case DO_CLOSE    :
  915.             erg = window->opened;
  916.             break;
  917.         case DO_DESTRUCT:
  918.             erg = delete_edit(icon,t_ptr);
  919.             break;
  920.         case DO_OPEN    :
  921.             erg = TRUE;
  922.             break;
  923.         case DO_INFO    :
  924.             erg = TRUE;
  925.             break;
  926.         case DO_HELP    :
  927.             erg = TRUE;
  928.             break;
  929.         case DO_LEFT    :
  930.             erg = t_ptr->block;
  931.             break;
  932.         case DO_RIGHT    :
  933.             erg = t_ptr->block;
  934.             break;
  935.         case DO_ONE_LEFT    :
  936.         case DO_ONE_RIGHT    :
  937.         case DO_BIG2SMALL    :
  938.         case DO_SMALL2BIG    :
  939.         case DO_CHNG_SMBG    :
  940.         case DO_CAPS        :
  941.         case DO_GO_BLK_A    :
  942.         case DO_GO_BLK_E    :
  943.             erg = t_ptr->block;
  944.             break;
  945.         case DO_FORMAT :
  946.             erg = t_ptr->loc_opt->umbrechen;
  947.             break;
  948.         case DO_PRINT    :
  949.             erg = TRUE;
  950.             break;
  951.         case DO_ABAND    :
  952.             if (t_ptr->namenlos)
  953.                 erg = FALSE;
  954.             else
  955.             {
  956.                 erg = TRUE;
  957.                 if (!ist_leer(&t_ptr->text) && t_ptr->moved!=0)
  958.                 {
  959.                     if (t_ptr->namenlos)
  960.                         strcpy(name, t_ptr->filename);
  961.                     else
  962.                         file_name(t_ptr->filename, name, FALSE);
  963.                     erg = (snote(1,ABANDON,name)==1);
  964.                 }
  965.             }
  966.             break;
  967.         case DO_SAVE    :
  968.             erg = TRUE;
  969.             break;
  970.         case DO_SAVENEW:
  971.             erg = TRUE;
  972.             break;
  973.         case DO_FIND    :
  974.             find_erg = find_dial(FALSE);
  975.             erg = (find_erg!=0);
  976.             break;
  977.         case DO_FINDNEXT:
  978.             erg = TRUE;
  979.             break;
  980.         case DO_ADD     :
  981.             erg = TRUE;
  982.             break;
  983.         case DO_GOTO    :
  984.             erg = goto_line_dial();
  985.             break;
  986.         case DO_CUTLINES:
  987.             erg = !t_ptr->loc_opt->umbrechen;
  988.             break;
  989.         case DO_TAB2LZ :
  990.             erg = t_ptr->loc_opt->tab;
  991.             break;
  992.         case DO_LZ2TAB :
  993.             erg = t_ptr->loc_opt->tab;
  994.             break;
  995.         case DO_UPDATE    :
  996.             erg = TRUE;
  997.             break;
  998.         case DO_ZEICHTAB:
  999.             ascii_wert = get_ascii();
  1000.             erg = (ascii_wert != -1);
  1001.             break;
  1002.         case DO_UMLAUT:
  1003.             erg = umlaut_dial();
  1004.             break;
  1005.         case DO_SWAPCHAR:
  1006.             erg = !t_ptr->block;
  1007.             break;
  1008.         case DO_AUTOSAVE :
  1009.             if (as_text && t_ptr->moved)
  1010.             {
  1011.                 WORD            min, btn;
  1012.  
  1013.                 min = local_time->tm_min - t_ptr->count;
  1014.                 if (min >= as_text_min)
  1015.                 {
  1016.                     if (as_text_ask)                /* Nachfrage ? */
  1017.                     {
  1018.                         FILENAME        name;
  1019.  
  1020.                         if (t_ptr->namenlos)
  1021.                             strcpy(name, t_ptr->filename);
  1022.                         else
  1023.                             file_name(t_ptr->filename, name, FALSE);
  1024.                         mybeep();
  1025.                         btn = snote(2, ASAVEASK, name);
  1026.                         if (btn == 1)
  1027.                             as_text = FALSE;
  1028.                     }
  1029.                     else
  1030.                         btn = 2;
  1031.  
  1032.                     t_ptr->count = local_time->tm_min;
  1033.                     erg = (btn == 2);
  1034.                 }
  1035.                 else
  1036.                     erg = FALSE;
  1037.             }
  1038.             else
  1039.             {
  1040.                 t_ptr->count = local_time->tm_min;
  1041.                 erg = FALSE;
  1042.             }
  1043.             break;
  1044.         case DO_FEHLER :
  1045.             erg = TRUE;
  1046.             break;
  1047.         default    :
  1048.             erg = FALSE;
  1049.     }
  1050.     return erg;
  1051. }
  1052.  
  1053. /***************************************************************************/
  1054. /* Operation durchführen                                                                    */
  1055. /***************************************************************************/
  1056.  
  1057. LOCAL WORD icon_edit(WORD icon, WORD action)
  1058. {
  1059.     PATH    name;
  1060.     TEXTP    t_ptr = get_text(icon);
  1061.     RING    r;
  1062.     WINDP    window;
  1063.     WORD    erg;
  1064.     BOOLEAN    ok;
  1065.     FSEL    fsel;
  1066.  
  1067.     window = get_window(icon);
  1068.     erg = 0;
  1069.     switch(action)
  1070.     {
  1071.         case DO_UNDO    :
  1072.             t_ptr->blk_mark_mode = FALSE;
  1073.             blk_demark(t_ptr);
  1074.             make_undo(t_ptr);
  1075.             erg = 1;
  1076.             break;
  1077.         case DO_CUT     :
  1078.             t_ptr->blk_mark_mode = FALSE;
  1079.             blk_cut(t_ptr,global_shift);
  1080.             restore_edit();
  1081.             erg = 1;
  1082.             break;
  1083.         case DO_COPY    :
  1084.             t_ptr->blk_mark_mode = FALSE;
  1085.             blk_copy(t_ptr,global_shift);
  1086.             restore_edit();
  1087.             erg = 1;
  1088.             break;
  1089.         case DO_LINECOPY:
  1090.             line_copy(t_ptr, global_shift);
  1091.             restore_edit();
  1092.             erg = 1;
  1093.             break;
  1094.         case DO_PASTE    :
  1095.             t_ptr->blk_mark_mode = FALSE;
  1096.             do_icon(iclipbrd, DO_UPDATE);
  1097.             blk_paste(t_ptr, &(get_text(iclipbrd)->text));
  1098.             if (t_ptr->loc_opt->umbrechen && t_ptr->loc_opt->format_by_paste)
  1099.                 format(t_ptr);
  1100.             restore_edit();
  1101.             erg = 1;
  1102.             break;
  1103.         case DO_DESTRUCT:
  1104.         case DO_CLEAR    :
  1105.             destruct(icon);
  1106.             erg = 1;
  1107.             break;
  1108.         case DO_SELALL :
  1109.             t_ptr->blk_mark_mode = FALSE;
  1110.             blk_mark_all(t_ptr);
  1111.             restore_edit();
  1112.             erg = 1;
  1113.             break;
  1114.         case DO_CLOSE    :
  1115.             t_ptr->blk_mark_mode = FALSE;
  1116.             close_window(window);
  1117.             erg = 1;
  1118.             break;
  1119.         case DO_OPEN    :
  1120.             t_ptr->blk_mark_mode = FALSE;
  1121.             if (!open_edit(icon))
  1122.                 erg = -1;
  1123.             else
  1124.                 erg = 1;
  1125.             break;
  1126.         case DO_INFO    :
  1127.             t_ptr->blk_mark_mode = FALSE;
  1128.             if (t_ptr->block)
  1129.                 block_info(t_ptr);
  1130.             else
  1131.                 info_edit(icon);
  1132.             erg = 1;
  1133.             break;
  1134.         case DO_HELP    :
  1135.             t_ptr->blk_mark_mode = FALSE;
  1136.             if (!t_ptr->block)
  1137.                 blk_mark_word(t_ptr);
  1138.             block_copy(t_ptr, &r);
  1139.             if (strlen(TEXT(FIRST(&r))) > 0)
  1140.                 erg = call_help(TEXT(FIRST(&r)));
  1141.             else
  1142.                 erg = call_hyp("main");
  1143.             kill_textring(&r);
  1144.             break;
  1145.         case DO_LEFT    :
  1146.             t_ptr->blk_mark_mode = FALSE;
  1147.             blk_left(t_ptr, FALSE);
  1148.             restore_edit();
  1149.             erg = 1;
  1150.             break;
  1151.         case DO_ONE_LEFT    :
  1152.             t_ptr->blk_mark_mode = FALSE;
  1153.             blk_left(t_ptr, TRUE);
  1154.             restore_edit();
  1155.             erg = 1;
  1156.             break;
  1157.         case DO_RIGHT    :
  1158.             t_ptr->blk_mark_mode = FALSE;
  1159.             blk_right(t_ptr, FALSE);
  1160.             restore_edit();
  1161.             erg = 1;
  1162.             break;
  1163.         case DO_ONE_RIGHT    :
  1164.             t_ptr->blk_mark_mode = FALSE;
  1165.             blk_right(t_ptr, TRUE);
  1166.             restore_edit();
  1167.             erg = 1;
  1168.             break;
  1169.         case DO_SMALL2BIG    :
  1170.             t_ptr->blk_mark_mode = FALSE;
  1171.             blk_upplow(t_ptr, BLK_UPPER);
  1172.             restore_edit();
  1173.             erg = 1;
  1174.             break;
  1175.         case DO_BIG2SMALL    :
  1176.             t_ptr->blk_mark_mode = FALSE;
  1177.             blk_upplow(t_ptr, BLK_LOWER);
  1178.             restore_edit();
  1179.             erg = 1;
  1180.             break;
  1181.         case DO_CHNG_SMBG    :
  1182.             t_ptr->blk_mark_mode = FALSE;
  1183.             blk_upplow(t_ptr, BLK_CH_UPLO);
  1184.             restore_edit();
  1185.             erg = 1;
  1186.             break;
  1187.         case DO_CAPS    :
  1188.             t_ptr->blk_mark_mode = FALSE;
  1189.             blk_upplow(t_ptr, BLK_CAPS);
  1190.             restore_edit();
  1191.             erg = 1;
  1192.             break;
  1193.         case DO_FORMAT :
  1194.             t_ptr->blk_mark_mode = FALSE;
  1195.             blk_demark(t_ptr);
  1196.             if (global_shift)
  1197.                 total_format(t_ptr);
  1198.             else
  1199.                 format(t_ptr);
  1200.             restore_edit();
  1201.             erg = 1;
  1202.             break;
  1203.         case DO_PRINT    :
  1204.             t_ptr->blk_mark_mode = FALSE;
  1205.             print_edit(t_ptr);
  1206.             erg = 1;
  1207.             break;
  1208.         case DO_ABAND    :
  1209. abandon:    strcpy(name, t_ptr->filename);
  1210.             desire_x = BildPos(t_ptr->xpos,t_ptr->cursor_line,t_ptr->loc_opt->tab,t_ptr->loc_opt->tabsize);
  1211.             desire_y = t_ptr->ypos;
  1212.             window->init = 1;             /* das will ich wieder haben */
  1213.             destruct_window(window);
  1214.             del_icon_from_desk(icon);
  1215.             destruct_text(t_ptr);
  1216.             del_icon(icon);
  1217.             setexcl(used_info,icon);
  1218.             icon = load_edit(name,FALSE,-1,-1,NULL);
  1219.             if (icon > 0)
  1220.             {
  1221.                 t_ptr = get_text(icon);
  1222.                 erg = -1;
  1223.                 if (t_ptr!=NULL)
  1224.                 {
  1225.                     goto_line(t_ptr, desire_x, desire_y);
  1226.                     restore_edit();
  1227.                     if (open_edit(icon))
  1228.                     {
  1229.                         memset(msgbuff, 0, (WORD) sizeof(msgbuff));
  1230.                         msgbuff[0] = WM_TOPPED;
  1231.                         msgbuff[3] = window->handle;
  1232.                         send_msg(gl_apid);
  1233.                         erg = 1;
  1234.                     }
  1235.                 }
  1236.             }
  1237.             clr_undo();
  1238.             break;
  1239.         case DO_SAVE    :
  1240.             if (!t_ptr->namenlos)
  1241.             {
  1242.                 t_ptr->blk_mark_mode = FALSE;
  1243.                 if (t_ptr->loc_opt->umbrechen)
  1244.                     save_absatz(t_ptr);                    /* Zeilenende korrigieren */
  1245.                 if (save(t_ptr)<0)
  1246.                     erg = -1;
  1247.                 else
  1248.                     erg = 1;
  1249.  
  1250.                 make_chg(icon,POS_CHANGE,0);            /* Headline schreiben */
  1251.                 restore_edit();
  1252.                 break;
  1253.             }
  1254.             /* Bei Namenlos zu DO_SAVENEW */
  1255.         case DO_SAVENEW:
  1256.             t_ptr->blk_mark_mode = FALSE;
  1257.             strcpy(fsel.suffix,"*.*");
  1258.             strcpy(fsel.name,"");
  1259.             if (t_ptr->block)
  1260.             {
  1261.                 if (save_new(name,&fsel, STRING(SAVEBLKSTR)))
  1262.                 {
  1263.                     TEXTP temp_ptr;
  1264.  
  1265.                     temp_ptr = new_text(TEMP_LINK);
  1266.                     if (t_ptr->loc_opt->umbrechen)    /* Zeilenende korrigieren */
  1267.                         save_absatz(t_ptr);
  1268.                     block_copy(t_ptr,&temp_ptr->text);    /* Block rauskopieren */
  1269.                     temp_ptr->cursor_line = FIRST(&t_ptr->text);
  1270.                     temp_ptr->loc_opt = t_ptr->loc_opt;
  1271.                     erg = save_as(temp_ptr,name);
  1272.                     destruct_text(temp_ptr);
  1273.                     if (erg==0)
  1274.                         erg = 1;
  1275.                 }
  1276.             }
  1277.             else
  1278.             {
  1279.                 if (save_new(name,&fsel, STRING(SAVEASSTR)))
  1280.                 {
  1281.                     if (t_ptr->loc_opt->umbrechen)    /* Zeilenende korrigieren */
  1282.                         save_absatz(t_ptr);
  1283.                     if ((erg=save_as(t_ptr,name))==0)
  1284.                     {
  1285.                         if (t_ptr->namenlos || note(1,GETNAME)==1)
  1286.                         {
  1287.                             /* OLGA informieren */
  1288.                             do_OLGA(OLGA_RENAME, t_ptr->filename, name);
  1289.                             do_OLGA(OLGA_UPDATE, name, NULL);
  1290.  
  1291.                             set_text_name(t_ptr, name, FALSE);
  1292.                             chg_edit_name(icon);
  1293.                             t_ptr->moved = 0;
  1294.                             t_ptr->file_date_time = file_time(name,NULL,NULL);
  1295.                             t_ptr->readonly = file_readonly(name);
  1296.                         }
  1297.                         make_chg(icon, TOTAL_CHANGE, 0); /* ggf. neue lok. Optionen! */
  1298.                         make_chg(icon, POS_CHANGE, 0);    /* Headline schreiben */
  1299.                         restore_edit();
  1300.                         ch_kurzel(t_ptr->loc_opt->kurzel, FALSE);
  1301.                         if (erg==0)
  1302.                             erg = 1;
  1303.                     }
  1304.                 }
  1305.             }
  1306.             break;
  1307.         case DO_FIND    :
  1308.             t_ptr->blk_mark_mode = FALSE;
  1309.             if (find_erg==1)
  1310.             {
  1311.                 if (start_find(t_ptr,FALSE)==0)
  1312.                 {
  1313.                     mybeep();
  1314.                     end_play();
  1315.                 }
  1316.             }
  1317.             else
  1318.                 if (find_erg==2)
  1319.                     start_replace(t_ptr, FALSE);
  1320.             erg = 1;
  1321.             break;
  1322.         case DO_FINDNEXT:
  1323.             t_ptr->blk_mark_mode = FALSE;
  1324.             if (do_next(t_ptr) != 1)
  1325.             {
  1326.                     mybeep();
  1327.                     end_play();
  1328.             }
  1329.             erg = 1;
  1330.             break;
  1331.         case DO_GOTO    :
  1332.             t_ptr->blk_mark_mode = FALSE;
  1333.             blk_demark(t_ptr);
  1334.             goto_line(t_ptr, desire_x, desire_y);
  1335.             restore_edit();
  1336.             erg = 1;
  1337.             break;
  1338.         case DO_CUTLINES:
  1339.             t_ptr->blk_mark_mode = FALSE;
  1340.             blk_demark(t_ptr);
  1341.             Busy_mouse();
  1342.             cut_lines(t_ptr);
  1343.             Last_mouse();
  1344.             restore_edit();
  1345.             erg = 1;
  1346.             break;
  1347.         case DO_TAB2LZ :
  1348.             t_ptr->blk_mark_mode = FALSE;
  1349.             blk_demark(t_ptr);
  1350.             tab2lz(t_ptr);
  1351.             erg = 1;
  1352.             break;
  1353.         case DO_LZ2TAB :
  1354.             t_ptr->blk_mark_mode = FALSE;
  1355.             blk_demark(t_ptr);
  1356.             lz2tab(t_ptr);
  1357.             erg = 1;
  1358.             break;
  1359.         case DO_ADD     :
  1360.             strcpy(fsel.suffix,"*.*");
  1361.             strcpy(fsel.name,"");
  1362.             if (global_shift)
  1363.                 ok = select_file(&fsel, name, STRING(INSNAMESTR));
  1364.             else
  1365.                 ok = select_file(&fsel, name, STRING(MERGESTR));
  1366.             if (ok)
  1367.             {
  1368.                 if (global_shift)                /* Dateinamen einfügen */
  1369.                 {
  1370.                     RING    temp_ring;
  1371.                     LINEP    col;
  1372.  
  1373.                     init_textring(&temp_ring);
  1374.                     col = new_col_w(name, (short)strlen(name));
  1375.  
  1376.  
  1377.  
  1378.  
  1379.                     col_insert(&(temp_ring.head), col);
  1380.                     blk_paste(t_ptr, &temp_ring);
  1381.                     restore_edit();
  1382.                     kill_textring(&temp_ring);
  1383.                 }
  1384.                 else                                /* Dateiinhalt einfügen */
  1385.                 {
  1386.                     TEXTP temp_ptr = new_text(TEMP_LINK);
  1387.  
  1388.                     if (temp_ptr!=NULL)
  1389.                     {
  1390.                         set_text_name(temp_ptr, name, FALSE);
  1391.                         if (!load(temp_ptr, FALSE))
  1392.                         {
  1393.                             blk_paste(t_ptr,&(temp_ptr->text));
  1394.                             restore_edit();
  1395.                         }
  1396.                         destruct_text(temp_ptr);
  1397.                     }
  1398.                 }
  1399.             }
  1400.             erg = 1;
  1401.             break;
  1402.         case DO_UPDATE    :
  1403.             if (file_exist(t_ptr->filename))
  1404.             {
  1405.                 BOOLEAN    read_only = file_readonly(t_ptr->filename);
  1406.  
  1407.                 if (read_only!=t_ptr->readonly)
  1408.                 {
  1409.                     t_ptr->readonly = read_only;
  1410.                     make_chg(icon,POS_CHANGE,0);        /* Headline schreiben */
  1411.                     restore_edit();
  1412.                 }
  1413.                 if (t_ptr->file_date_time!=-1L)
  1414.                 {
  1415.                     LONG date_time = file_time(t_ptr->filename,NULL,NULL);
  1416.  
  1417.                     if (date_time!=t_ptr->file_date_time)
  1418.                     {
  1419.                         FILENAME    name;
  1420.  
  1421.                         file_name(t_ptr->filename, name, FALSE);
  1422.                         if (snote(1,MOVED3,name)==1)
  1423.                             goto abandon;
  1424.                         else
  1425.                             t_ptr->file_date_time = date_time;
  1426.                     }
  1427.                 }
  1428.             }
  1429.             erg = 1;
  1430.             break;
  1431.         case DO_ZEICHTAB:
  1432.             if (ascii_wert != -1 )
  1433.                 char_insert(t_ptr, ascii_wert);
  1434.             restore_edit();
  1435.             erg = 1;
  1436.             break;
  1437.         case DO_UMLAUT:
  1438.             change_umlaute(t_ptr);
  1439.             erg = 1;
  1440.             break;
  1441.         case DO_SWAPCHAR:
  1442.             char_swap(t_ptr);
  1443.             restore_edit();
  1444.             break;
  1445.         case DO_AUTOSAVE:
  1446.             icon_edit(icon, DO_SAVE);
  1447.             break;
  1448.         case DO_FEHLER :
  1449.             if (error[0][0] != EOS)
  1450.             {
  1451.                 blk_demark(t_ptr);
  1452.                 restore_edit();
  1453.                 handle_error(t_ptr);
  1454.             }
  1455.             break;
  1456.     }
  1457.     return erg;
  1458. }
  1459.  
  1460. /***************************************************************************/
  1461. /* Ein Icon wurde auf ein Text-Icon geschoben                                        */
  1462. /***************************************************************************/
  1463.  
  1464. LOCAL BOOLEAN icon_drag (WORD icon, WORD source)
  1465. {
  1466.     TEXTP t_ptr;
  1467.  
  1468.     switch (source)
  1469.     {
  1470.         case DRAGDROP_FILE :
  1471.             t_ptr = get_text(icon);
  1472.             if (drag_filename[0] != EOS && t_ptr != NULL)
  1473.             {
  1474.                 TEXTP temp_ptr = new_text(TEMP_LINK);
  1475.  
  1476.                 if (temp_ptr!=NULL)
  1477.                 {
  1478.                     set_text_name(temp_ptr, drag_filename, FALSE);
  1479.                     if (!load(temp_ptr, FALSE))
  1480.                     {
  1481.                         blk_paste(t_ptr,&(temp_ptr->text));
  1482.                         restore_edit();
  1483.                     }
  1484.                     destruct_text(temp_ptr);
  1485.                     return TRUE;
  1486.                 }
  1487.             }
  1488.             drag_filename[0] = EOS;
  1489.             break;
  1490.         case DRAGDROP_PATH :
  1491.             t_ptr = get_text(icon);
  1492.             if (drag_filename[0] != EOS && t_ptr != NULL)
  1493.             {
  1494.                 RING    temp_ring;
  1495.                 LINEP    col;
  1496.  
  1497.                 init_textring(&temp_ring);
  1498.                 col = new_col_w(drag_filename, (short)strlen(drag_filename));
  1499.                 col_insert(&(temp_ring.head), col);
  1500.                 if (drag_data_size > 1)
  1501.                 {
  1502.                     /* mehr als ein ARGS -> Zeilenvorschub */
  1503.                     col = new_col_w("", 0);
  1504.                     col_append(&temp_ring, col);
  1505.                 }
  1506.                 blk_paste(t_ptr, &temp_ring);
  1507.                 restore_edit();
  1508.                 kill_textring(&temp_ring);
  1509.                 return TRUE;
  1510.             }
  1511.             drag_filename[0] = EOS;
  1512.             break;
  1513.         case DRAGDROP_DATA :
  1514.             if (drag_data_size > 0 && drag_data != NULL)
  1515.             {
  1516.                 RING    temp_ring;
  1517.                 LINEP    col;
  1518.                 UBYTE    *p1, *p2, zeile[256];
  1519.                 LONG    delta;
  1520.                 LINEP    lauf;
  1521.  
  1522.                 t_ptr = get_text(icon);
  1523.                 init_textring(&temp_ring);
  1524.                 lauf = &temp_ring.head;
  1525.                 p1 = drag_data;
  1526.                 p2 = strchr(p1, '\r');
  1527.                 if (p2 != NULL)                            /* mehrere Zeilen? */
  1528.                 {
  1529.                     while (p2 != NULL)
  1530.                     {
  1531.                         delta = p2 - p1;
  1532.                         strncpy(zeile, p1, delta);
  1533.                         zeile[delta] = EOS;
  1534.                         col = new_col_w(zeile, (short)strlen(zeile));
  1535.                         col_insert(lauf, col);
  1536.                         NEXT(lauf);
  1537.                         p1 = p2 + 2;                        /* \r\n überspringen */
  1538.                         p2 = strchr(p1, '\r');
  1539.                         temp_ring.lines++;
  1540.                     }
  1541.                 }
  1542.                 else                                            /* nur eine Zeile ohne \r\n */
  1543.                 {
  1544.                     col = new_col_w(drag_data, (short)strlen(drag_data));
  1545.                     col_insert(lauf, col);
  1546.                 }
  1547.                 blk_paste(t_ptr, &temp_ring);
  1548.                 restore_edit();
  1549.                 kill_textring(&temp_ring);
  1550.                 Mfree(drag_data);                            /* Speicher wieder freigeben */
  1551.                 drag_data_size = 0L;
  1552.                 return TRUE;
  1553.             }
  1554.             break;
  1555.         default:                        /* ein anderes Text-Icon wurde gedragged */
  1556.             t_ptr = get_text(source);
  1557.             if (global_shift)
  1558.             {
  1559.                 strcpy(drag_filename, t_ptr->filename);
  1560.                 icon_drag(icon, DRAGDROP_PATH);
  1561.                 return TRUE;
  1562.             }
  1563.             else if (t_ptr!=NULL)
  1564.             {
  1565.                 blk_paste(get_text(icon),&(t_ptr->text));
  1566.                 restore_edit();
  1567.                 return TRUE;
  1568.             }
  1569.             break;
  1570.     }
  1571.     return FALSE;
  1572. }
  1573.  
  1574. /***************************************************************************/
  1575.  
  1576. VOID blink_edit(VOID)
  1577. {
  1578.     WINDOWP    window;
  1579.     TEXTP     t_ptr;
  1580.  
  1581.     window = top();
  1582.     if (window!=NULL && window->class==CLASS_EDIT)
  1583.     {
  1584.         t_ptr = get_text(window->link);
  1585.         if (t_ptr->cursor)
  1586.         {
  1587.             if (t_ptr->blink)         /* gerade wg. Blinken aus */
  1588.                 t_ptr->blink = FALSE;
  1589.             else
  1590.                 t_ptr->blink = TRUE;
  1591.             cursor(window,t_ptr);
  1592.         }
  1593.     }
  1594. }
  1595.  
  1596. VOID onblink_edit(VOID)
  1597. {
  1598.     WINDOWP    window;
  1599.     TEXTP     t_ptr;
  1600.  
  1601.     window = top();
  1602.     if (window!=NULL && window->class==CLASS_EDIT)
  1603.     {
  1604.         t_ptr = get_text(window->link);
  1605.         if (t_ptr->cursor)
  1606.         {
  1607.             cursor(window,t_ptr);
  1608.             t_ptr->blink = FALSE;
  1609.         }
  1610.     }
  1611. }
  1612.  
  1613. VOID offblink_edit(VOID)
  1614. {
  1615.     WINDOWP    window;
  1616.     TEXTP     t_ptr;
  1617.  
  1618.     window = top();
  1619.     if (window!=NULL && window->class==CLASS_EDIT)
  1620.     {
  1621.         t_ptr = get_text(window->link);
  1622.         if (t_ptr->cursor && !t_ptr->blink)
  1623.         {
  1624.             cursor(window,t_ptr);
  1625.         }
  1626.     }
  1627. }
  1628.  
  1629. /***************************************************************************/
  1630. /* Tastenverarbeitung                                                                        */
  1631. /***************************************************************************/
  1632.  
  1633. VOID make_chg (WORD link, WORD change, LONG ypos)
  1634. {
  1635.     WORD i;
  1636.  
  1637.     if (change==TOTAL_CHANGE)
  1638.     {
  1639.         for (i=chg_anz; (--i)>=0; )            /* unnützte Änderung */
  1640.             if (chg[i].link==link)
  1641.             {
  1642.                 if (chg[i].c==LINE_CHANGE && chg[i].y>=ypos)
  1643.                     chg[i].c = NOP_CHANGE;
  1644.                 else if (chg[i].c==SCROLL_DOWN && chg[i].y>=ypos)
  1645.                     chg[i].c = NOP_CHANGE;
  1646.                 else if (chg[i].c==SCROLL_UP && chg[i].y>=ypos)
  1647.                     chg[i].c = NOP_CHANGE;
  1648.                 else if (chg[i].c==TOTAL_CHANGE && chg[i].y>=ypos)
  1649.                 {
  1650.                     chg[i].y = ypos;
  1651.                     break;
  1652.                 }
  1653.             }
  1654.     }
  1655.     if (change==LINE_CHANGE)
  1656.     {
  1657.         for (i=chg_anz; (--i)>=0; )            /* gleiche Änderung */
  1658.             if (chg[i].link==link && chg[i].c==change && chg[i].y==ypos)
  1659.                 return;
  1660.     }
  1661.     if (change==POS_CHANGE)
  1662.     {
  1663.         for (i=chg_anz; (--i)>=0; )
  1664.             if (chg[i].link==link && chg[i].c==change)
  1665.                 return;
  1666.     }
  1667.     if (chg_anz>=MAX_CHG)
  1668.     {
  1669.         inote(1,FATALERR,0);
  1670.         return;
  1671.     }
  1672.     chg[chg_anz].link = link;
  1673.     chg[chg_anz].c = change;
  1674.     chg[chg_anz].y = ypos;
  1675.     setincl(chg_links,link);
  1676.     chg_anz++;
  1677. }
  1678.  
  1679. VOID pos_korr(WINDOWP window, TEXTP t_ptr, BOOLEAN in_desk)
  1680. {
  1681.     WORD    x_new;
  1682.     LONG    y_new;
  1683.  
  1684.     y_new = t_ptr->ypos - window->doc.y;
  1685.  
  1686.     if (y_new < 0L)
  1687.     {
  1688.         if (y_new == -1L)
  1689.             arrow_window(window, WA_UPLINE, 1);
  1690.         else
  1691.             arrow_window(window, WA_UPLINE, window->w_hight/2-y_new);
  1692.     }
  1693.     else if (y_new>=window->w_hight)
  1694.     {
  1695.         if (y_new == window->w_hight)
  1696.             arrow_window(window, WA_DNLINE, 1);
  1697.         else
  1698.             arrow_window(window, WA_DNLINE, y_new-window->w_hight/2);
  1699.     }
  1700.  
  1701.     x_new = cursor_xpos(t_ptr, t_ptr->xpos)- (short) window->doc.x * gl_wchar;
  1702.     if (x_new < 0)
  1703.         arrow_window(window, WA_LFLINE, -(x_new/gl_wchar)+3);
  1704.     else if (x_new >= window->work.w)
  1705.         arrow_window(window, WA_RTLINE, (x_new-window->work.w)/gl_wchar+3);
  1706. }
  1707.  
  1708. LOCAL VOID restore_offdesk(WINDOWP window, TCHANGE *c, WORD c_anz, TEXTP t_ptr)
  1709. {
  1710.     WORD    y_screen;
  1711.     BOOLEAN    done = FALSE;
  1712.     RECT    a;
  1713.  
  1714.     for (; (--c_anz)>=0; c++)
  1715.     {
  1716.         switch (c->c)
  1717.         {
  1718.         case POS_CHANGE     :
  1719.             if (window->class==CLASS_EDIT)
  1720.             {
  1721.                 a = window->work;
  1722.                 a.h = sys_hchar;
  1723.                 redraw_window(window,&a);
  1724.             }
  1725.             change_window(window, (t_ptr->moved!=0));
  1726.             pos_korr(window, t_ptr, FALSE);
  1727.             break;
  1728.         case LINE_CHANGE:
  1729.             y_screen = (short) (c->y - window->doc.y);
  1730.             if (y_screen>=0 && y_screen<window->w_hight)
  1731.             {
  1732.                 a = window->work;
  1733.                 a.y += y_screen*window->yfac;
  1734.                 a.h = window->yfac;
  1735.                 redraw_window(window,&a);
  1736.             }
  1737.             break;
  1738.         case TOTAL_CHANGE  :
  1739.         case BLK_CHANGE     :
  1740.         case SCROLL_UP      :
  1741.         case SCROLL_DOWN :
  1742.             if (!done)
  1743.                 redraw_window(window, &window->work);
  1744.             done = TRUE;
  1745.             break;
  1746.         case MOVE_UP:
  1747.             arrow_window(window, WA_DNLINE, c->y);
  1748.             break;
  1749.         case MOVE_DOWN:
  1750.             arrow_window(window, WA_UPLINE, c->y);
  1751.             break;
  1752.         }
  1753.     }
  1754. }
  1755.  
  1756. LOCAL VOID restore_indesk(WINDOWP window, TCHANGE *c, WORD c_anz, TEXTP t_ptr)
  1757. {
  1758.     RECT    a;
  1759.     WORD    y_screen, help;
  1760.     LONG    z1,z2;
  1761.  
  1762.     for (; (--c_anz)>=0; c++)
  1763.     {
  1764.         switch (c->c)
  1765.         {
  1766.         case POS_CHANGE     :
  1767.             set_clip (FALSE, NULL);
  1768.             if (window->class == CLASS_EDIT)
  1769.                 head_out(window, t_ptr);
  1770.             change_window(window, (t_ptr->moved!=0));
  1771.             pos_korr(window, t_ptr, TRUE);
  1772.             break;
  1773.         case LINE_CHANGE:
  1774.             y_screen = (short)(c->y - window->doc.y);
  1775.             if (y_screen<window->w_hight)
  1776.             {
  1777.                 set_clip (FALSE, NULL);
  1778.                 line_out(window, t_ptr, y_screen);
  1779.             }
  1780.             break;
  1781.         case TOTAL_CHANGE  :
  1782.             y_screen = (short) (c->y - window->doc.y);
  1783.             if (y_screen>0 && y_screen<window->w_hight)
  1784.             {
  1785.                 help = window->yfac*y_screen;
  1786.                 a = window->work;
  1787.                 a.h -= help;
  1788.                 a.y += help;
  1789.                 set_clip(TRUE, &a);
  1790.             }
  1791.             else
  1792.                 set_clip (FALSE, NULL);
  1793.             bild_out(window,t_ptr);
  1794.             break;
  1795.         case SCROLL_UP      :
  1796.             y_screen = (short) (c->y - window->doc.y);
  1797.             if (y_screen<window->w_hight-1)
  1798.             {
  1799.                 help = window->yfac*(y_screen+1);
  1800.                 a = window->work;
  1801.                 a.h -= help;
  1802.                 a.y += help;
  1803.                 set_clip (FALSE, NULL);
  1804.                 scroll_vertical (&a, window->yfac);
  1805.             }
  1806.             if (y_screen<window->w_hight)
  1807.             {
  1808.                 set_clip (FALSE, NULL);
  1809.                 line_out(window, t_ptr, window->w_hight-1);
  1810.             }
  1811.             break;
  1812.         case SCROLL_DOWN:
  1813.             y_screen = (short) (c->y - window->doc.y);
  1814.             if (y_screen<window->w_hight-1)
  1815.             {
  1816.                 a = window->work;
  1817.                 a.h -= window->yfac*(y_screen+1);
  1818.                 a.y += window->yfac*y_screen;
  1819.                 set_clip (FALSE, NULL);
  1820.                 scroll_vertical (&a, -window->yfac);
  1821.             }
  1822.             /* Die neue Zeile wird mit LINE_CHANGE gezeichnet */
  1823.             break;
  1824.         case MOVE_UP:
  1825.             arrow_window(window, WA_DNLINE, c->y);
  1826.             break;
  1827.         case MOVE_DOWN      :
  1828.             arrow_window(window, WA_UPLINE, c->y);
  1829.             break;
  1830.         case BLK_CHANGE     :
  1831.             set_clip (FALSE, NULL);
  1832.             z1 = c->y;
  1833.             c++; c_anz--;
  1834.             z2 = c->y;
  1835.             bild_blkout(window,t_ptr,z1,z2);
  1836.             break;
  1837.         }
  1838.     }
  1839. }
  1840.  
  1841. VOID restore_edit(VOID)
  1842. {
  1843.     WINDOWP    window;
  1844.     TEXTP     t_ptr;
  1845.     WORD        i, c_anz, link, max;
  1846.     TCHANGE    c[MAX_CHG], *c_ptr;
  1847.  
  1848.     if (!chg_anz) return;
  1849.     Hide_mouse();
  1850.     max = setmax(chg_links);
  1851.     for (link=setmin(chg_links); link<=max; link++) if(setin(chg_links,link))
  1852.     {
  1853.         window = get_window(link);
  1854.         if (window==NULL) continue;                    /* Kommt vor (Prj_Text mit 10001) */
  1855.         c_anz = 0;
  1856.         c_ptr = chg;
  1857.         for (i=chg_anz; (--i)>=0; c_ptr++)
  1858.             if (c_ptr->link==link && c_ptr->c!=NOP_CHANGE)
  1859.                 c[c_anz++] = *c_ptr;
  1860.  
  1861.         t_ptr = get_text(window->link);
  1862.         if (window->doc.h != t_ptr->text.lines)
  1863.         {
  1864.             window->doc.h = t_ptr->text.lines;
  1865.             set_sliders(window, VERTICAL, SLPOS+SLSIZE);
  1866.         }
  1867.         if (window->opened || (window->flags & WI_ICONIFIED))
  1868.         {
  1869.             /* Fenster Top und auf Bildschirm ? */
  1870.             if (free_for_draw(window))
  1871.                 restore_indesk(window, c, c_anz, t_ptr);
  1872.             else
  1873.                 restore_offdesk(window, c, c_anz, t_ptr);
  1874.         }
  1875.     }
  1876.     Show_mouse();
  1877.     chg_anz = 0;            /* Keine Änderungen mehr */
  1878.     setclr(chg_links);
  1879. }
  1880.  
  1881. /***************************************************************************/
  1882.  
  1883. LOCAL VOID destruct(WORD icon)
  1884. {
  1885.     TEXTP t_ptr = get_text(icon);
  1886.     WINDP window = get_window(icon);
  1887.  
  1888.     /* wenn text aus Projekt kam, Cursor-Pos. sichern! */
  1889.     update_lastPos(t_ptr->filename, t_ptr->xpos, t_ptr->ypos);
  1890.  
  1891.     destruct_window(window);
  1892.     del_icon_from_desk(icon);
  1893.     destruct_text(t_ptr);
  1894.     del_icon(icon);
  1895.     setexcl(used_info,icon);
  1896.     clr_undo();
  1897.     do_all_icon(prj_type,DO_UPDATE);        /* Projekte updaten */
  1898. }
  1899.  
  1900. /***************************************************************************/
  1901.  
  1902. LOCAL WORD crt_new_text(CONST UBYTE *filename, WORD icon_x, WORD icon_y, RECT *win)
  1903. {
  1904.     TEXTP         t_ptr;
  1905.     WORD            icon;
  1906.     WINDP         window;
  1907.     FILENAME        datei;
  1908.     PATH            name;
  1909.     BOOLEAN        namenlos;
  1910.  
  1911.     if (!is_mem_free())
  1912.         return -1;
  1913.     strcpy(name, filename);
  1914.     if (name[0]==EOS)
  1915.     {
  1916.         UBYTE    str[20], *ptr;
  1917.         WORD    len;
  1918.  
  1919.  
  1920.         strcpy(name, STRING(NAMENLOS));
  1921.         itoa(++namenlos_anz,str,10);
  1922.         len = (short) strlen(str);
  1923.         ptr = strchr(name,'$');
  1924.         if (ptr != NULL)
  1925.         {
  1926.             MOVE(ptr+len, ptr+1, (short) strlen(ptr));
  1927.             COPYB(ptr,str,len);
  1928.         }
  1929.         strcpy(datei, name);
  1930.         namenlos = TRUE;
  1931.     }
  1932.     else
  1933.     {
  1934.         file_name(name,datei, FALSE);
  1935.         namenlos = FALSE;
  1936.     }
  1937.     icon = add_icon_to_desk(ITEXT, datei, icon_x, icon_y);
  1938.     if (icon <= 0)
  1939.         return -1;
  1940.     if (!add_icon(edit_type, icon))
  1941.     {
  1942.         del_icon_from_desk(icon);
  1943.         return -1;
  1944.     }
  1945.     t_ptr = new_text(icon);                                     /* Neuen Text anlegen        */
  1946.     if (t_ptr==NULL)
  1947.     {
  1948.         del_icon(icon);
  1949.         del_icon_from_desk(icon);
  1950.         return -1;
  1951.     }
  1952.     set_text_name(t_ptr, name, namenlos);
  1953.     setincl(used_info,icon);
  1954.     if ((window=create_window(KIND, CLASS_EDIT, icon, crt_edit))==NULL)
  1955.     {
  1956.         setexcl(used_info,icon);
  1957.         destruct_text(t_ptr);
  1958.         del_icon(icon);
  1959.         del_icon_from_desk(icon);
  1960.         return -1;
  1961.     }
  1962.     if (win!=NULL && win->w>0)
  1963.     {
  1964.         size_window(window,win,FALSE);
  1965.     }
  1966.     if (!namenlos)
  1967.     {
  1968.         do_all_icon(prj_type,DO_UPDATE);        /* Projekte updaten */
  1969.     }
  1970.     t_ptr->count = local_time->tm_min;
  1971.     return(icon);
  1972. }
  1973.  
  1974. /***************************************************************************/
  1975. /* Kreieren eines Fensters                                                                 */
  1976. /***************************************************************************/
  1977.  
  1978. LOCAL VOID crt_edit (WORD icon, WINDOWP window)
  1979. {
  1980.     PATH        name;
  1981.     WORD        initw, inith;
  1982.     TEXTP     t_ptr;
  1983.  
  1984.     t_ptr  = get_text(icon);
  1985.     initw  = min ((desk.w / gl_wchar) * gl_wchar - 7 * gl_wchar, 80 * gl_wchar);
  1986.     inith  = (desk.h / gl_hchar) * gl_hchar - 7 * gl_hchar;
  1987.  
  1988.     window->flags        = FLAGS;
  1989.     window->doc.w        = MAX_LINE_LEN + 1;
  1990.     window->doc.h        = t_ptr->text.lines;
  1991.     window->changed    = (t_ptr->moved!=0);
  1992.     window->xfac        = gl_wchar;
  1993.     window->yfac        = gl_hchar;
  1994.     window->w_width    = initw/gl_wchar;
  1995.     window->w_hight    = inith/gl_hchar;
  1996.     window->work.x        = sys_wchar + 2 * 8;
  1997.     window->work.y        = 60;
  1998.     window->work.w        = initw;
  1999.     window->work.h        = inith;
  2000.     window->mousenum    = TEXT_CRSR;
  2001.     window->draw        = wi_draw_edit;
  2002.     window->click        = wi_click;
  2003.     window->key         = wi_key;
  2004.     window->top            = wi_top;
  2005.     window->ontop        = wi_top;
  2006.     window->icon        = winicon;
  2007.     window->iconify    = wi_iconify;
  2008.     window->uniconify    = wi_uniconify;
  2009.     window->special    = NULL;
  2010.     window->close        = NULL;
  2011.     make_shortpath(t_ptr->filename, name, 70);
  2012.     set_wname(window, name);
  2013. } /* crt_edit */
  2014.  
  2015. /***************************************************************************/
  2016. /* Öffnen des Objekts                                                                        */
  2017. /***************************************************************************/
  2018.  
  2019. LOCAL BOOLEAN open_edit (WORD icon)
  2020. {
  2021.     BOOLEAN        ok;
  2022.     WINDOWP    window = get_window(icon);
  2023.  
  2024.     ok = TRUE;
  2025.  
  2026.     if (window->flags & WI_ICONIFIED)
  2027.         uniconify_window(window, NULL);
  2028.     else if (window->opened)
  2029.         top_window(window);
  2030.     else
  2031.     {
  2032.         TEXTP t_ptr = get_text(window->link);
  2033.  
  2034.         window->doc.x = 0;
  2035.         window->doc.y = 0;
  2036.         window->doc.h = t_ptr->text.lines;
  2037.         pos_korr(window, t_ptr, FALSE);
  2038.         ok = open_window (window);
  2039.         ch_kurzel(t_ptr->loc_opt->kurzel, FALSE);
  2040.     }
  2041.     return ok;
  2042. } /* open_edit */
  2043.  
  2044. /***************************************************************************/
  2045. /* Info des Objekts                                                                            */
  2046. /* auch für Trash und Clipbrd                                                             */
  2047. /***************************************************************************/
  2048.  
  2049.  
  2050. GLOBAL BOOLEAN info_edit (WORD icon)
  2051. {
  2052.     UBYTE            str[32], date[11];
  2053.     TEXTP         t_ptr = get_text(icon);
  2054.     WORD            erg;
  2055.     LineEnding    ending;
  2056.  
  2057.     ltoa(textring_bytes(&t_ptr->text,t_ptr->ending), str, 10);
  2058.     fill_ptext (textinfo, INFGROSS, str);        /* Größe in Bytes */
  2059.     ltoa(t_ptr->text.lines, str, 10);
  2060.     fill_ptext (textinfo, INFZEILE, str);        /* Größe in Zeilen */
  2061.     make_shortpath(t_ptr->filename, str, 30);
  2062.     fill_ptext (textinfo, INFNAME, str);        /* Name mit Pfad */
  2063.     if (t_ptr->namenlos)
  2064.         str[0] = date[0] = EOS;
  2065.     else
  2066.         file_time (t_ptr->filename, date, str);
  2067.     fill_ptext (textinfo, INFDATUM, date);     /* Datum */
  2068.     fill_ptext (textinfo, INFZEIT, str);        /* Uhrzeit */
  2069.  
  2070.  
  2071.     select_objc(textinfo, INFTOS, (t_ptr->ending == tos));
  2072.     select_objc(textinfo, INFUNIX, (t_ptr->ending == unix));
  2073.     select_objc(textinfo, INFMAC, (t_ptr->ending == apple));
  2074.     ending = t_ptr->ending;
  2075.  
  2076.     Arrow_mouse();
  2077.     if (!is_icon_on_desk(icon))                        /* Dateien aus einem Projekt */
  2078.     {
  2079.         disable_objc(textinfo, INFTOS, TRUE);
  2080.         disable_objc(textinfo, INFUNIX, TRUE);
  2081.         disable_objc(textinfo, INFMAC, TRUE);
  2082.         erg = HndlDial(textinfo, 0, FALSE, NULL, NULL);
  2083.     }
  2084.     else
  2085.     {
  2086.         disable_objc(textinfo, INFTOS, FALSE);
  2087.         disable_objc(textinfo, INFUNIX, FALSE);
  2088.         disable_objc(textinfo, INFMAC, FALSE);
  2089.         erg = HndlDial(textinfo, 0, FALSE, NULL, NULL);
  2090.     }
  2091.     Last_mouse();
  2092.     if (erg == INFOK)
  2093.     {
  2094.         if (get_select(textinfo, INFTOS))
  2095.             t_ptr->ending = tos;
  2096.         if (get_select(textinfo, INFUNIX))
  2097.             t_ptr->ending = unix;
  2098.         if (get_select(textinfo, INFMAC))
  2099.             t_ptr->ending = apple;
  2100.  
  2101.         if (t_ptr->ending != ending)
  2102.         {
  2103.             t_ptr->moved++;
  2104.             make_chg(t_ptr->link, POS_CHANGE, 0);     /* Damit Infozeile einen '*' bekommt */
  2105.             restore_edit();
  2106.         }
  2107.     }
  2108.     return TRUE;
  2109. }
  2110.  
  2111. GLOBAL VOID init_edit(VOID)
  2112. {
  2113.     namenlos_anz = 0;
  2114.     setclr(used_info);
  2115.     setclr(chg_links);
  2116.     drag_filename[0] = EOS;
  2117.     edit_type = decl_icon_type(icon_test,icon_edit,icon_exist,icon_drag);
  2118. }
  2119.  
  2120. GLOBAL VOID    cursor_off(WORD wHandle)
  2121. {
  2122.     WINDOWP    window;
  2123.     TEXTP     t_ptr;
  2124.  
  2125.     window = find_window(wHandle);
  2126.     if (window!=NULL && window->class==CLASS_EDIT)
  2127.     {
  2128.         t_ptr = get_text(window->link);
  2129.         if (t_ptr->cursor)
  2130.             t_ptr->cursor = FALSE;
  2131.     }
  2132. }
  2133.  
  2134. GLOBAL VOID    cursor_on(WORD wHandle)
  2135. {
  2136.     WINDOWP    window;
  2137.     TEXTP     t_ptr;
  2138.  
  2139.     window = find_window(wHandle);
  2140.     if (window!=NULL && window->class==CLASS_EDIT)
  2141.     {
  2142.         t_ptr = get_text(window->link);
  2143.         if (!t_ptr->cursor)
  2144.             t_ptr->cursor = TRUE;
  2145.     }
  2146. }
  2147.  
  2148. GLOBAL VOID close_edit(CONST UBYTE *file, WORD flag)
  2149. {
  2150.     WORD i, min;
  2151.  
  2152.     min = setmin(used_info);
  2153.     for (i = setmax(used_info); i >= min; i--)
  2154.         if (setin(used_info, i))
  2155.         {
  2156.             TEXTP t_ptr = get_text(i);
  2157.  
  2158.             if (filematch(t_ptr->filename, file))
  2159.             {
  2160.                 switch (flag)
  2161.                 {
  2162.                     case 0 :        /* sichern ohne schließen */
  2163.                         do_icon(i, DO_SAVE);
  2164.                         break;
  2165.                     case 1 :        /* sichern und schließen */
  2166.                         do_icon(i, DO_DESTRUCT);
  2167.                         break;
  2168.                     case 2 :        /* schließen ohne sichern */
  2169.                         t_ptr->moved = 0;
  2170.                         do_icon(i, DO_DESTRUCT);
  2171.                         break;
  2172.                     default:
  2173. #ifdef DEBUG_SE
  2174. Debug("qed: close_edit: Unknown SE_CLOSE Flag %d\n", flag);
  2175. #endif
  2176.                         break;
  2177.                 }
  2178.             }
  2179.         }
  2180. }
  2181.  
  2182. GLOBAL WORD get_ascii(VOID)
  2183. {
  2184.     WORD    antw;
  2185.  
  2186.     Arrow_mouse();
  2187.     antw = ins_extchar(winFont.ID, 13);
  2188.     Last_mouse();
  2189.     if (antw != 0)
  2190.         return antw;
  2191.     else
  2192.         return -1;
  2193. }
  2194.  
  2195. GLOBAL VOID set_info(TEXTP t_ptr, UBYTE *str)
  2196. {
  2197.     strcpy(t_ptr->info_str, str);
  2198. }
  2199.  
  2200. GLOBAL VOID unset_info(TEXTP t_ptr)
  2201. {
  2202.     if (t_ptr->info_str[0] != EOS)
  2203.         strcpy(t_ptr->info_str, "");
  2204. }
  2205.